home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 43 / Amiga Format CD43 (1999)(Future Publishing)(GB)(Track 1 of 2)[!][issue 1999-09].iso / -serious- / sound / newmiditools / src / newmidiout2.c < prev    next >
C/C++ Source or Header  |  1999-06-14  |  18KB  |  758 lines
  1. #ifndef MAKE_ID
  2. #define MAKE_ID(a,b,c,d) ((ULONG) (a)<<24 | (ULONG) (b)<<16 | (ULONG) (c)<<8 | (ULONG) (d))
  3. #endif
  4.  
  5. //      NEW MIDI OUT TOOL 2
  6. //      BY G.O.Jones 1998
  7. //      -----------------
  8.  
  9. #include "bars.h"
  10. #include <clib/debug_protos.h>
  11. #include <clib/dos_protos.h>
  12. #include <libraries/dos.h>
  13. #include <devices/serial.h>
  14. #include <proto/exec.h>
  15. #include <proto/graphics.h>
  16. #include <proto/intuition.h>
  17. #include <exec/memory.h>
  18. #include <string.h>
  19. #include <intuition/intuition.h>
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <ctype.h>
  23.  
  24. #define ID_MOU MAKE_ID('M','O','U','2')
  25. #define LEFT 7
  26. #define TOP  15
  27.  
  28. void removetool(struct OutTool *tool);
  29. void sendsysex(char *buff, short size);
  30. int openserial(char *devicename, int unit);
  31. void closeserial(void);
  32. struct Event *processeventcode(struct Event *event);
  33. static void deletetool(struct OutTool *copy);
  34.  
  35. extern struct Functions *functions;
  36. struct Task *task;
  37. BOOL serial = FALSE;
  38. char name[300];
  39. char un[300];
  40. int unit=0;
  41.  
  42. static struct MsgPort  *SerialMP;         /* Message port pointer */
  43. static struct IOExtSer *SerialIO;         /* I/O request pointer */
  44.  
  45. static UWORD chip outtool[]=
  46. {
  47. /*-------- plane # 0 --------*/
  48.  
  49.   0x0000,  0x0000,
  50.   0x3fff,  0xff00,
  51.   0x3000,  0x0300,
  52.   0x3000,  0x0300,
  53.   0x3000,  0x0300,
  54.   0x3000,  0x0300,
  55.   0x3100,  0x1300,
  56.   0x3040,  0x8300,
  57.   0x300c,  0x0300,
  58.   0x3000,  0x0300,
  59.   0x3fff,  0xff00,
  60.   0x0000,  0x0000,
  61.  
  62. /*-------- plane # 1 --------*/
  63.  
  64.   0x0000,  0x0000,
  65.   0x0000,  0x0300,
  66.   0x0fff,  0xff00,
  67.   0x0fff,  0xff00,
  68.   0xcfff,  0xff00,
  69.   0xcfff,  0xff00,
  70.   0xceff,  0xef00,
  71.   0xcfbf,  0x7f00,
  72.   0x0ff3,  0xff00,
  73.   0x0fff,  0xff00,
  74.   0x1fff,  0xff00,
  75.   0x0000,  0x0000,
  76.  
  77. /*-------- plane # 2 --------*/
  78.  
  79.   0x0000,  0x0000,
  80.   0x0000,  0x0000,
  81.   0x0073,  0x8000,
  82.   0x03f3,  0xf000,
  83.   0x07ff,  0xf800,
  84.   0x0fff,  0xfc00,
  85.   0x0eff,  0xec00,
  86.   0x07bf,  0x7800,
  87.   0x03f3,  0xf000,
  88.   0x007f,  0x8000,
  89.   0x0000,  0x0000,
  90.   0x0000,  0x0000
  91. };
  92.  struct  Image outtoolimage =
  93.  {
  94.  0,0,
  95.  24 , 12 , 3 ,
  96.  outtool,
  97.  0x7,0x00,
  98.  NULL,
  99.  };
  100.  
  101. struct OutTool {
  102.                     struct Tool tool;
  103.                     BOOL Note;
  104.                     BOOL Pitch;
  105.                     BOOL MonoAT;
  106.                     BOOL PolyAT;
  107.                     BOOL CChange;
  108.                     BOOL PChange;
  109.                     BOOL SysEx;
  110.                };
  111.  
  112. extern struct Functions *functions;
  113.  
  114. // ----------------------------------------------
  115.  
  116. static struct IntuiText sysexgadText = {
  117.         4,0,JAM1,
  118.         2,1,
  119.         NULL,
  120.         "System Exclusive",
  121.         NULL
  122. };
  123.  
  124. static struct Gadget sysexgad = {
  125.         NULL,
  126.         LEFT,TOP+66,
  127.         130,9,
  128.         GADGHBOX+GADGHIMAGE,
  129.         RELVERIFY+GADGIMMEDIATE+TOGGLESELECT,
  130.         BOOLGADGET,
  131.         NULL,
  132.         NULL,
  133.         &sysexgadText,
  134.         NULL,
  135.         NULL,
  136.         6,
  137.         NULL
  138. };
  139.  
  140. static struct IntuiText pchangegadText = {
  141.         4,0,JAM1,
  142.         12,1,
  143.         NULL,
  144.         "Program Change",
  145.         NULL
  146. };
  147.  
  148. static struct Gadget pchangegad = {
  149.         &sysexgad,
  150.         LEFT,TOP+55,
  151.         130,9,
  152.         GADGHBOX+GADGHIMAGE,
  153.         RELVERIFY+GADGIMMEDIATE+TOGGLESELECT,
  154.         BOOLGADGET,
  155.         NULL,
  156.         NULL,
  157.         &pchangegadText,
  158.         NULL,
  159.         NULL,
  160.         5,
  161.         NULL
  162. };
  163.  
  164. static struct IntuiText cchangegadText = {
  165.         4,0,JAM1,
  166.         12,1,
  167.         NULL,
  168.         "Control Change",
  169.         NULL
  170. };
  171.  
  172. static struct Gadget cchangegad = {
  173.         &pchangegad,
  174.         LEFT,TOP+44,
  175.         130,9,
  176.         GADGHBOX+GADGHIMAGE,
  177.         RELVERIFY+GADGIMMEDIATE+TOGGLESELECT,
  178.         BOOLGADGET,
  179.         NULL,
  180.         NULL,
  181.         &cchangegadText,
  182.         NULL,
  183.         NULL,
  184.         4,
  185.         NULL
  186. };
  187.  
  188. static struct IntuiText polyATgadText = {
  189.         4,0,JAM1,
  190.         5,1,
  191.         NULL,
  192.         "Poly Aftertouch",
  193.         NULL
  194. };
  195.  
  196. static struct Gadget polyATgad = {
  197.         &cchangegad,
  198.         LEFT,TOP+33,
  199.         130,9,
  200.         GADGHBOX+GADGHIMAGE,
  201.         RELVERIFY+GADGIMMEDIATE+TOGGLESELECT,
  202.         BOOLGADGET,
  203.         NULL,
  204.         NULL,
  205.         &polyATgadText,
  206.         NULL,
  207.         NULL,
  208.         3,
  209.         NULL
  210. };
  211.  
  212. static struct IntuiText monoATgadText = {
  213.         4,0,JAM1,
  214.         5,1,
  215.         NULL,
  216.         "Mono Aftertouch",
  217.         NULL
  218. };
  219.  
  220. static struct Gadget monoATgad = {
  221.         &polyATgad,
  222.         LEFT,TOP+22,
  223.         130,9,
  224.         GADGHBOX+GADGHIMAGE,
  225.         RELVERIFY+GADGIMMEDIATE+TOGGLESELECT,
  226.         BOOLGADGET,
  227.         NULL,
  228.         NULL,
  229.         &monoATgadText,
  230.         NULL,
  231.         NULL,
  232.         2,
  233.         NULL
  234. };
  235.  
  236. static struct IntuiText pitchgadText = {
  237.         4,0,JAM1,
  238.         23,1,
  239.         NULL,
  240.         "Pitch Wheel",
  241.         NULL
  242. };
  243.  
  244. static struct Gadget pitchgad = {
  245.         &monoATgad,
  246.         LEFT,TOP+11,
  247.         130,9,
  248.         GADGHBOX+GADGHIMAGE,
  249.         RELVERIFY+GADGIMMEDIATE+TOGGLESELECT,
  250.         BOOLGADGET,
  251.         NULL,
  252.         NULL,
  253.         &pitchgadText,
  254.         NULL,
  255.         NULL,
  256.         1,
  257.         NULL
  258. };
  259.  
  260. static struct IntuiText notegadText = {
  261.         4,0,JAM1,
  262.         22,1,
  263.         NULL,
  264.         "Note On/Off",
  265.         NULL
  266. };
  267.  
  268. static struct Gadget notegad = {
  269.         &pitchgad,
  270.         LEFT,TOP,
  271.         130,9,
  272.         GADGHBOX+GADGHIMAGE,
  273.         RELVERIFY+GADGIMMEDIATE+TOGGLESELECT,
  274.         BOOLGADGET,
  275.         NULL,
  276.         NULL,
  277.         ¬egadText,
  278.         NULL,
  279.         NULL,
  280.         0,
  281.         NULL
  282. };
  283.  
  284. // ------------------------------------------------
  285.  
  286. #define GadgetList  notegad;
  287.  
  288. static struct NewWindow outNewWindowStructure1 = {
  289.         400,100,
  290.         145,95,
  291.         6,1,
  292.         GADGETDOWN+CLOSEWINDOW,
  293.         WINDOWDRAG+WINDOWDEPTH+WINDOWCLOSE+ACTIVATE+NOCAREREFRESH,
  294.         ¬egad,
  295.         NULL,
  296.         "New MIDI Out 1",
  297.         NULL,
  298.         NULL,
  299.         5,5,
  300.         0,0,
  301.         CUSTOMSCREEN
  302. };
  303.  
  304. void setgadgettext(struct Window *window, short id, char *text)
  305. {
  306.     struct Gadget *gadget = (struct Gadget *) (*functions->GetGadget)(window,id);
  307.     if (gadget) {
  308.         gadget->GadgetText->IText = text;
  309.         (functions->DrawEmbossed)(window,id);
  310.     }
  311. }
  312.  
  313. void sendsysex(char *buff,short size)
  314. {
  315.             if(size>1500)
  316.             (*functions->transportcommand)(TC_STOP,functions->timenow);
  317.  
  318.             SerialIO->IOSer.io_Length=size;
  319.             SerialIO->IOSer.io_Data=(APTR)buff;
  320.             SerialIO->IOSer.io_Command=CMD_WRITE;
  321.             if(serial)
  322.             {
  323.                 DoIO((struct IORequest *)SerialIO);
  324.                 WaitTOF();
  325.             }
  326. }
  327.  
  328. void edittoolcode(struct OutTool *tool)
  329. {
  330.     struct IntuiMessage *message;
  331.     struct Window *window;
  332.     long class, code;
  333.     short refresh = 1;
  334.     struct Gadget *gadget;
  335.     struct NewWindow *newwindow;
  336.  
  337.     outNewWindowStructure1.Screen = functions->screen;
  338.     if (tool->tool.touched & TOUCH_EDIT) {
  339.         outNewWindowStructure1.LeftEdge = tool->tool.left;
  340.         outNewWindowStructure1.TopEdge = tool->tool.top;
  341.     }
  342.     if (!tool->tool.touched) {
  343.         tool->tool.touched = TOUCH_INIT;
  344.  
  345.                     tool->Note= TRUE;
  346.                     tool->Pitch= TRUE;
  347.                     tool->MonoAT= TRUE;
  348.                     tool->PolyAT= TRUE;
  349.                     tool->CChange= TRUE;
  350.                     tool->PChange= TRUE;
  351.                     tool->SysEx= FALSE;
  352.     }
  353.     newwindow = (struct NewWindow *)
  354.         (*functions->DupeNewWindow)(&outNewWindowStructure1);
  355.     if (!newwindow) return;
  356.     newwindow->Title = 0;
  357.     newwindow->Flags |= BORDERLESS;
  358.     newwindow->Flags &= ~0xF;
  359.     newwindow->DetailPen = 0;
  360.     newwindow->BlockPen = 0;
  361.     window = (struct Window *)
  362.         (*functions->FlashyOpenWindow)(newwindow);
  363.     if (!window) return;
  364.     tool->tool.window = window;
  365.     (*functions->EmbossWindowOn)(window,WINDOWCLOSE|WINDOWDEPTH|WINDOWDRAG,
  366.         "New Midi Out",(short)-1,(short)-1,0,0);
  367.  
  368.     (*functions->EmbossOn)(window,0,1);
  369.     (*functions->EmbossOn)(window,1,1);
  370.     (*functions->EmbossOn)(window,2,1);
  371.     (*functions->EmbossOn)(window,3,1);
  372.     (*functions->EmbossOn)(window,4,1);
  373.     (*functions->EmbossOn)(window,5,1);
  374.     (*functions->EmbossOn)(window,6,1);
  375.  
  376.  
  377.     for (;;) {
  378.         if (refresh)
  379.         {
  380.  
  381.             (*functions->SelectEmbossed)(window,0,tool->Note);
  382.             (*functions->SelectEmbossed)(window,1,tool->Pitch);
  383.             (*functions->SelectEmbossed)(window,2,tool->MonoAT);
  384.             (*functions->SelectEmbossed)(window,3,tool->PolyAT);
  385.             (*functions->SelectEmbossed)(window,4,tool->CChange);
  386.             (*functions->SelectEmbossed)(window,5,tool->PChange);
  387.             (*functions->SelectEmbossed)(window,6,tool->SysEx);
  388.  
  389.         }
  390.         refresh = 0;
  391.         message = (struct IntuiMessage *) (*functions->GetIntuiMessage)(window);
  392.         class = message->Class;
  393.         code = message->Code;
  394.         gadget = (struct Gadget *) message->IAddress;
  395.         class = (*functions->SystemGadgets)(window,class,gadget,code);
  396.         ReplyMsg((struct Message *)message);
  397.         if (class == CLOSEWINDOW) break;
  398.         else if (class == GADGETDOWN) {
  399.  
  400.  
  401.             }
  402.  
  403.  
  404.         else if (class == GADGETUP)  {
  405.  
  406.             switch(gadget->GadgetID)
  407.             {
  408.                       case 0:
  409.                       tool->Note = !tool->Note;
  410.                       refresh = 1;
  411.                       break;
  412.  
  413.                       case 1:
  414.                       tool->Pitch = !tool->Pitch;
  415.                       refresh = 1;
  416.                       break;
  417.  
  418.                       case 2:
  419.                       tool->MonoAT = !tool->MonoAT;
  420.                       refresh = 1;
  421.                       break;
  422.  
  423.                       case 3:
  424.                       tool->PolyAT = !tool->PolyAT;
  425.                       refresh = 1;
  426.                       break;
  427.  
  428.                       case 4:
  429.                       tool->CChange = !tool->CChange;
  430.                       refresh = 1;
  431.                       break;
  432.  
  433.                       case 5:
  434.                       tool->PChange = !tool->PChange;
  435.                       refresh = 1;
  436.                       break;
  437.  
  438.                       case 6:
  439.                       tool->SysEx = !tool->SysEx;
  440.                       refresh = 1;
  441.                       break;
  442.  
  443.                       default:
  444.                         break;
  445.  
  446.             }
  447.        }
  448.     }
  449.  
  450.     (*functions->EmbossOff)(window,0);
  451.     (*functions->EmbossOff)(window,1);
  452.     (*functions->EmbossOff)(window,2);
  453.     (*functions->EmbossOff)(window,3);
  454.     (*functions->EmbossOff)(window,4);
  455.     (*functions->EmbossOff)(window,5);
  456.     (*functions->EmbossOff)(window,6);
  457.  
  458.     tool->tool.window = 0;
  459.     tool->tool.left = window->LeftEdge;
  460.     tool->tool.top = window->TopEdge;
  461.     tool->tool.touched = TOUCH_INIT | TOUCH_EDIT;
  462.     (*functions->FlashyCloseWindow)(window);
  463.     (*functions->DeleteNewWindow)(newwindow);
  464. }
  465.  
  466. extern printf();
  467.  
  468. struct Event *processeventcode(struct Event *event)
  469. {
  470.     UBYTE data[10];
  471.     UBYTE channel;
  472.     struct OutTool *tool = (struct OutTool *) event->tool;
  473.     BOOL skip = FALSE;
  474.  
  475.     if(!serial)
  476.     {
  477.         if((openserial(name, unit)) != 3) serial = FALSE;
  478.         else serial = TRUE;
  479.     }
  480.  
  481.     channel = (UBYTE)tool->tool.track->channelout;
  482.  
  483.     if (!tool->tool.touched) {
  484.         tool->tool.touched = TOUCH_INIT;
  485.                     tool->Note= TRUE;
  486.                     tool->Pitch= TRUE;
  487.                     tool->MonoAT= TRUE;
  488.                     tool->PolyAT= TRUE;
  489.                     tool->CChange= TRUE;
  490.                     tool->PChange= TRUE;
  491.                     tool->SysEx= FALSE;
  492.     }                                    
  493.  
  494.     switch (event->status)
  495.     {
  496.         case MIDI_NOTEON:
  497.         if(tool->Note)
  498.         {
  499.             data[0] = 0x90|channel;
  500.             data[1] = event->byte1;
  501.             data[2] = event->byte2;
  502.             SerialIO->IOSer.io_Length=3;
  503.             SerialIO->IOSer.io_Data=(APTR)data;
  504.             SerialIO->IOSer.io_Command=CMD_WRITE;
  505.         }
  506.         break;
  507.  
  508.         case MIDI_NOTEOFF:
  509.         if(tool->Note)
  510.         {
  511.             data[0] = 0x80|channel;
  512.             data[1] = event->byte1;
  513.             data[2] = event->byte2;
  514.             SerialIO->IOSer.io_Length=3;
  515.             SerialIO->IOSer.io_Data=(APTR)data;
  516.             SerialIO->IOSer.io_Command=CMD_WRITE;
  517.         }
  518.         break;
  519.  
  520.         case MIDI_PTOUCH:
  521.         if(tool->PolyAT)
  522.         {
  523.             data[0] = 0xA0|channel;
  524.             data[1] = event->byte1;
  525.             data[2] = event->byte2;
  526.             SerialIO->IOSer.io_Length=3;
  527.             SerialIO->IOSer.io_Data=(APTR)data;
  528.             SerialIO->IOSer.io_Command=CMD_WRITE;
  529.         }
  530.         break;
  531.  
  532.         case MIDI_MTOUCH:
  533.         if(tool->MonoAT)
  534.         {
  535.             data[0] = 0xD0|channel;
  536.             data[1] = event->byte1;
  537.             SerialIO->IOSer.io_Length=2;
  538.             SerialIO->IOSer.io_Data=(APTR)data;
  539.             SerialIO->IOSer.io_Command=CMD_WRITE;
  540.         }
  541.         break;
  542.  
  543.         case MIDI_PCHANGE:
  544.         if(tool->PChange)
  545.         {
  546.             data[0] = 0xC0|channel;
  547.             data[1] = event->byte1;
  548.             SerialIO->IOSer.io_Length=2;
  549.             SerialIO->IOSer.io_Data=(APTR)data;
  550.             SerialIO->IOSer.io_Command=CMD_WRITE;
  551.         }
  552.         break;
  553.  
  554.         case MIDI_PBEND:
  555.         if(tool->Pitch)
  556.         {
  557.             data[0] = 0xE0|channel;
  558.             data[1] = event->byte1;
  559.             data[2] = event->byte2;
  560.             SerialIO->IOSer.io_Length=3;
  561.             SerialIO->IOSer.io_Data=(APTR)data;
  562.             SerialIO->IOSer.io_Command=CMD_WRITE;
  563.         }
  564.         break;
  565.  
  566.         case MIDI_CCHANGE:
  567.             if(tool->CChange)
  568.             {
  569.                 data[0] = 0xB0|channel;
  570.                 data[1] = (UBYTE)event->byte1;
  571.                 data[2] = (UBYTE)event->byte2;
  572.                 SerialIO->IOSer.io_Length=3;
  573.                 SerialIO->IOSer.io_Data=(APTR)data;
  574.                 SerialIO->IOSer.io_Command=CMD_WRITE;
  575.             }
  576.         break;
  577.  
  578.         case MIDI_SYSX:
  579.         if(tool->SysEx)
  580.         {
  581.             struct StringEvent *se= (struct StringEvent *) event;
  582.  
  583.             sendsysex(se->string->string, se->string->length);
  584.         }
  585.         break;
  586.  
  587.         case MIDI_MTC:
  588.         data[0] = 0xF1;
  589.         SerialIO->IOSer.io_Length=1;
  590.         SerialIO->IOSer.io_Data=(APTR)data;
  591.         SerialIO->IOSer.io_Command=CMD_WRITE;
  592.         break;
  593.  
  594.         case MIDI_CLOCK:
  595.         data[0] = 0xF8;
  596.         SerialIO->IOSer.io_Length=1;
  597.         SerialIO->IOSer.io_Data=(APTR)data;
  598.         SerialIO->IOSer.io_Command=CMD_WRITE;
  599.         break;
  600.  
  601.         case MIDI_SONGPP:
  602.         data[0] = 0xF2;
  603.         data[1] = event->byte1;
  604.         data[2] = event->byte2;
  605.         SerialIO->IOSer.io_Length=3;
  606.         SerialIO->IOSer.io_Data=(APTR)data;
  607.         SerialIO->IOSer.io_Command=CMD_WRITE;
  608.         break;
  609.  
  610.         case MIDI_SONGS:
  611.         data[0] = 0xF3;
  612.         SerialIO->IOSer.io_Length=1;
  613.         SerialIO->IOSer.io_Data=(APTR)data;
  614.         SerialIO->IOSer.io_Command=CMD_WRITE;
  615.         break;
  616.  
  617.         case MIDI_START:
  618.         data[0] = 0xFA;
  619.         SerialIO->IOSer.io_Length=1;
  620.         SerialIO->IOSer.io_Data=(APTR)data;
  621.         SerialIO->IOSer.io_Command=CMD_WRITE;
  622.         break;
  623.  
  624.         case MIDI_STOP:
  625.         data[0] = 0xFC;
  626.         SerialIO->IOSer.io_Length=1;
  627.         SerialIO->IOSer.io_Data=(APTR)data;
  628.         SerialIO->IOSer.io_Command=CMD_WRITE;
  629.         break;
  630.  
  631.         case MIDI_CONTINUE:
  632.         data[0] = 0xFB;
  633.         SerialIO->IOSer.io_Length=1;
  634.         SerialIO->IOSer.io_Data=(APTR)data;
  635.         SerialIO->IOSer.io_Command=CMD_WRITE;
  636.         break;
  637.  
  638.         case MIDI_SENSE:
  639.         data[0] = 0xFE;
  640.         SerialIO->IOSer.io_Length=1;
  641.         SerialIO->IOSer.io_Data=(APTR)data;
  642.         SerialIO->IOSer.io_Command=CMD_WRITE;
  643.         break;
  644.  
  645.         default:
  646.         break;
  647.     }
  648.  
  649.     if(serial) DoIO((struct IORequest *)SerialIO);
  650.  
  651. (*functions->freeevent)(event);
  652. return(0);
  653. }
  654.  
  655. static struct ToolMaster master;
  656.  
  657.  
  658. void   removetool(struct OutTool *tool)
  659. {
  660.     closeserial();
  661. }
  662.  
  663. struct ToolMaster *inittoolmaster(void)
  664. {
  665.     BPTR prefs;
  666.     int i;
  667.  
  668.     memset((char *)&master,0,sizeof(struct ToolMaster));
  669.     master.toolsize = sizeof(struct OutTool);
  670.     master.toolid = ID_MOU;
  671.     master.edittool = edittoolcode;
  672.     master.deletetool = deletetool;
  673.     master.removetool = removetool;
  674.     master.image = &outtoolimage;
  675.     strcpy(master.name,"New MIDI Out 2");
  676.     master.processevent = processeventcode;
  677.     master.tooltype = TOOL_OUTPUT|TOOL_ONTIME|TOOL_MIDI;
  678.  
  679.     prefs = Open("envarc:NewMidiOut2.prefs",MODE_OLDFILE);
  680.  
  681.     if(prefs)
  682.     {
  683.         FGets(prefs,name,299);
  684.         for(i=0; i<299; i++)
  685.         {
  686.             if(isspace(name[i])) break;
  687.         }
  688.  
  689.         name[i] = NULL;
  690.  
  691.         FGets(prefs,un,299);
  692.         for(i=0; i<299; i++)
  693.         {
  694.             if(isspace(un[i])) break;
  695.         }
  696.  
  697.         un[i] = NULL;
  698.         unit = atoi(un);
  699.         Close(prefs);
  700.     }
  701.     return(&master);
  702. }
  703.  
  704. int openserial(char *devicename, int unit)
  705. {
  706.         if (SerialMP=CreateMsgPort())
  707.         {
  708.             if (SerialIO=(struct IOExtSer *)CreateExtIO(SerialMP,sizeof(struct IOExtSer)) )
  709.             {
  710.                 SerialIO->io_SerFlags|= SERF_SHARED;
  711.  
  712.                 if (OpenDevice(devicename,unit,(struct IORequest *)SerialIO,0))
  713.                 {
  714.                     return 0;
  715.                 }
  716.                 else
  717.                 {
  718.                     SerialIO->IOSer.io_Command  = SDCMD_QUERY;
  719.                     DoIO((struct IORequest *)SerialIO);             /* execute query */
  720.  
  721.                     SerialIO->IOSer.io_Command  = SDCMD_SETPARAMS;
  722.                     SerialIO->io_SerFlags &= ~SERF_PARTY_ON;
  723.                     SerialIO->io_SerFlags|=(SERF_RAD_BOOGIE|SERF_XDISABLED);
  724.                     SerialIO->io_Baud = 31250;
  725.                     DoIO((struct IORequest *)SerialIO);
  726.  
  727.                 }
  728.             }
  729.             else return 1;
  730.         }
  731.         else return 2;
  732.  
  733. return 3;
  734. }
  735.  
  736. void closeserial(void)
  737. {
  738.     if (SerialIO)
  739.     {
  740.         if (!(CheckIO(SerialIO)))
  741.         {
  742.             AbortIO((struct IORequest *)SerialIO); 
  743.         }                                     
  744.         WaitIO((struct IORequest *)SerialIO);
  745.  
  746.         CloseDevice((struct IORequest *)SerialIO);
  747.         DeleteExtIO((struct IORequest *)SerialIO);
  748.         DeletePort(SerialMP);
  749.     }
  750. }
  751.  
  752.  
  753. static void deletetool(struct OutTool *copy)
  754. {
  755.   functions->myfree(copy, sizeof(struct OutTool));
  756. }
  757.  
  758.